home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / BYacc-CW 1.9 / main.c < prev    next >
Text File  |  1995-10-09  |  7KB  |  384 lines
  1. #ifdef __MWERKS__
  2. #include "GIJO.h"
  3. #endif
  4.  
  5. #include <signal.h>
  6. #include "defs.h"
  7.  
  8. #include <unix.h>
  9.  
  10. char dflag;
  11. char lflag;
  12. char rflag;
  13. char tflag;
  14. char vflag;
  15.  
  16. char *symbol_prefix;
  17. char *file_prefix = "y";
  18. char *myname = "yacc";
  19. char *temp_form = "yacc.XXXXXXX";
  20.  
  21. int lineno;
  22. int y_outline;
  23.  
  24. char *action_file_name;
  25. char *code_file_name;
  26. char *defines_file_name;
  27. char *input_file_name = "";
  28. char *output_file_name;
  29. char *text_file_name;
  30. char *union_file_name;
  31. char *verbose_file_name;
  32.  
  33. FILE *action_file;    /*  a temp file, used to save actions associated    */
  34.             /*  with rules until the parser is written        */
  35. FILE *code_file;    /*  y.code.c (used when the -r option is specified) */
  36. FILE *defines_file;    /*  y.tab.h                        */
  37. FILE *input_file;    /*  the input file                    */
  38. FILE *output_file;    /*  y.tab.c                        */
  39. FILE *text_file;    /*  a temp file, used to save text until all        */
  40.             /*  symbols have been defined                */
  41. FILE *union_file;    /*  a temp file, used to save the union            */
  42.             /*  definition until all symbol have been        */
  43.             /*  defined                        */
  44. FILE *verbose_file;    /*  y.output                        */
  45.  
  46. int nitems;
  47. int nrules;
  48. int nsyms;
  49. int ntokens;
  50. int nvars;
  51.  
  52. int   start_symbol;
  53. char  **symbol_name;
  54. short *symbol_value;
  55. short *symbol_prec;
  56. char  *symbol_assoc;
  57.  
  58. short *ritem;
  59. short *rlhs;
  60. short *rrhs;
  61. short *rprec;
  62. char  *rassoc;
  63. short **derives;
  64. char *nullable;
  65.  
  66. #ifdef __MWERKS__
  67. #define    mktemp    tmpnam
  68. #endif
  69.  
  70. extern char *mktemp();
  71. extern char *getenv();
  72.  
  73.  
  74. void done(int k)
  75. {
  76.     if (action_file) { fclose(action_file); unlink(action_file_name); }
  77.     if (text_file) { fclose(text_file); unlink(text_file_name); }
  78.     if (union_file) { fclose(union_file); unlink(union_file_name); }
  79.     exit(k);
  80. }
  81.  
  82.  
  83. static void onintr(int /*signo*/)
  84. {
  85.     done(1);
  86. }
  87.  
  88.  
  89. static void set_signals(void)
  90. {
  91. #ifdef SIGINT
  92.     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
  93.     signal(SIGINT, onintr);
  94. #endif
  95. #ifdef SIGTERM
  96.     if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
  97.     signal(SIGTERM, onintr);
  98. #endif
  99. #ifdef SIGHUP
  100.     if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
  101.     signal(SIGHUP, onintr);
  102. #endif
  103. }
  104.  
  105.  
  106. static void usage(void)
  107. {
  108.     fprintf(stderr, "usage: %s [-dlrtv] [-b file_prefix] [-p symbol_prefix] filename\n", myname);
  109.     exit(1);
  110. }
  111.  
  112.  
  113. static void getargs(int argc, char *argv[])
  114. {
  115.     register int i;
  116.     register char *s;
  117.  
  118.     if (argc > 0) myname = argv[0];
  119.     for (i = 1; i < argc; ++i)
  120.     {
  121.     s = argv[i];
  122.     if (*s != '-') break;
  123.     switch (*++s)
  124.     {
  125.     case '\0':
  126.         input_file = stdin;
  127.         if (i + 1 < argc) usage();
  128.         return;
  129.  
  130.     case '-':
  131.         ++i;
  132.         goto no_more_options;
  133.  
  134.     case 'b':
  135.         if (*++s)
  136.          file_prefix = s;
  137.         else if (++i < argc)
  138.         file_prefix = argv[i];
  139.         else
  140.         usage();
  141.         continue;
  142.  
  143.     case 'd':
  144.         dflag = 1;
  145.         break;
  146.  
  147.     case 'l':
  148.         lflag = 1;
  149.         break;
  150.  
  151.     case 'p':
  152.         if (*++s)
  153.         symbol_prefix = s;
  154.         else if (++i < argc)
  155.         symbol_prefix = argv[i];
  156.         else
  157.         usage();
  158.         continue;
  159.  
  160.     case 'r':
  161.         rflag = 1;
  162.         break;
  163.  
  164.     case 't':
  165.         tflag = 1;
  166.         break;
  167.  
  168.     case 'v':
  169.         vflag = 1;
  170.         break;
  171.  
  172.     default:
  173.         usage();
  174.     }
  175.  
  176.     for (;;)
  177.     {
  178.         switch (*++s)
  179.         {
  180.         case '\0':
  181.         goto end_of_option;
  182.  
  183.         case 'd':
  184.         dflag = 1;
  185.         break;
  186.  
  187.         case 'l':
  188.         lflag = 1;
  189.         break;
  190.  
  191.         case 'r':
  192.         rflag = 1;
  193.         break;
  194.  
  195.         case 't':
  196.         tflag = 1;
  197.         break;
  198.  
  199.         case 'v':
  200.         vflag = 1;
  201.         break;
  202.  
  203.         default:
  204.         usage();
  205.         }
  206.     }
  207. end_of_option:;
  208.     }
  209.  
  210. no_more_options:;
  211.     if (i + 1 != argc) usage();
  212.     input_file_name = argv[i];
  213. }
  214.  
  215.  
  216. char *allocate(unsigned n)
  217. {
  218.     register char *p;
  219.  
  220.     p = NULL;
  221.     if (n)
  222.     {
  223.     p = CALLOC(1, n);
  224.     if (!p) no_space();
  225.     }
  226.     return (p);
  227. }
  228.  
  229.  
  230. static void create_file_names(void)
  231. {
  232.     int i, len;
  233.     char *tmpdir;
  234.  
  235.     tmpdir = getenv("TMPDIR");
  236.     if (tmpdir == 0) tmpdir = "/tmp";
  237.  
  238.     len = strlen(tmpdir);
  239.     i = len + 13;
  240.     if (len && tmpdir[len-1] != '/')
  241.     ++i;
  242.  
  243.     action_file_name = MALLOC(i);
  244.     if (action_file_name == 0) no_space();
  245.     text_file_name = MALLOC(i);
  246.     if (text_file_name == 0) no_space();
  247.     union_file_name = MALLOC(i);
  248.     if (union_file_name == 0) no_space();
  249.  
  250.     strcpy(action_file_name, tmpdir);
  251.     strcpy(text_file_name, tmpdir);
  252.     strcpy(union_file_name, tmpdir);
  253.  
  254.     if (len && tmpdir[len - 1] != '/')
  255.     {
  256.     action_file_name[len] = '/';
  257.     text_file_name[len] = '/';
  258.     union_file_name[len] = '/';
  259.     ++len;
  260.     }
  261.  
  262.     strcpy(action_file_name + len, temp_form);
  263.     strcpy(text_file_name + len, temp_form);
  264.     strcpy(union_file_name + len, temp_form);
  265.  
  266.     action_file_name[len + 5] = 'a';
  267.     text_file_name[len + 5] = 't';
  268.     union_file_name[len + 5] = 'u';
  269.  
  270.     mktemp(action_file_name);
  271.     mktemp(text_file_name);
  272.     mktemp(union_file_name);
  273.  
  274.     len = strlen(file_prefix);
  275.  
  276.     output_file_name = MALLOC(len + 7);
  277.     if (output_file_name == 0)
  278.     no_space();
  279.     strcpy(output_file_name, file_prefix);
  280.     strcpy(output_file_name + len, OUTPUT_SUFFIX);
  281.  
  282.     if (rflag)
  283.     {
  284.     code_file_name = MALLOC(len + 8);
  285.     if (code_file_name == 0)
  286.         no_space();
  287.     strcpy(code_file_name, file_prefix);
  288.     strcpy(code_file_name + len, CODE_SUFFIX);
  289.     }
  290.     else
  291.     code_file_name = output_file_name;
  292.  
  293.     if (dflag)
  294.     {
  295.     defines_file_name = MALLOC(len + 7);
  296.     if (defines_file_name == 0)
  297.         no_space();
  298.     strcpy(defines_file_name, file_prefix);
  299.     strcpy(defines_file_name + len, DEFINES_SUFFIX);
  300.     }
  301.  
  302.     if (vflag)
  303.     {
  304.     verbose_file_name = MALLOC(len + 8);
  305.     if (verbose_file_name == 0)
  306.         no_space();
  307.     strcpy(verbose_file_name, file_prefix);
  308.     strcpy(verbose_file_name + len, VERBOSE_SUFFIX);
  309.     }
  310. }
  311.  
  312.  
  313. static void open_files(void)
  314. {
  315.     create_file_names();
  316.  
  317.     if (input_file == 0)
  318.     {
  319.     input_file = fopen(input_file_name, "r");
  320.     if (input_file == 0)
  321.         open_error(input_file_name);
  322.     }
  323.  
  324.     action_file = fopen(action_file_name, "w");
  325.     if (action_file == 0)
  326.     open_error(action_file_name);
  327.  
  328.     text_file = fopen(text_file_name, "w");
  329.     if (text_file == 0)
  330.     open_error(text_file_name);
  331.  
  332.     if (vflag)
  333.     {
  334.     verbose_file = fopen(verbose_file_name, "w");
  335.     if (verbose_file == 0)
  336.         open_error(verbose_file_name);
  337.     }
  338.  
  339.     if (dflag)
  340.     {
  341.     defines_file = fopen(defines_file_name, "w");
  342.     if (defines_file == 0)
  343.         open_error(defines_file_name);
  344.     union_file = fopen(union_file_name, "w");
  345.     if (union_file ==  0)
  346.         open_error(union_file_name);
  347.     }
  348.  
  349.     output_file = fopen(output_file_name, "w");
  350.     if (output_file == 0)
  351.     open_error(output_file_name);
  352.  
  353.     if (rflag)
  354.     {
  355.     code_file = fopen(code_file_name, "w");
  356.     if (code_file == 0)
  357.         open_error(code_file_name);
  358.     }
  359.     else
  360.     code_file = output_file;
  361. }
  362.  
  363. #ifdef __GIJO__
  364. short main(short argc, char **argv)
  365. #else
  366. int
  367. main(argc, argv)
  368. int argc;
  369. char *argv[];
  370. #endif
  371. {
  372.     set_signals();
  373.     getargs(argc, argv);
  374.     open_files();
  375.     reader();
  376.     lr0();
  377.     lalr();
  378.     make_parser();
  379.     verbose();
  380.     output();
  381.     done(0);
  382.     /*NOTREACHED*/
  383.     return(0);
  384. }